/**
 * AI模型配置管理器 - 统一管理AI模型API密钥和配置信息
 * 
 * 提供功能：
 * - 加载/保存AI模型配置到localStorage
 * - 获取默认模型配置
 * - 获取指定模型配置
 * - 验证API密钥格式
 * 
 * 支持的模型：DeepSeek-R1、豆包、通义千问、ChatGPT等
 */

// 模型配置接口
export interface ModelConfig {
  apiKey: string;
  apiBase: string;
}

// AI模型配置接口
export interface AIModelSettings {
  defaultModel: string;
  models: Record<string, ModelConfig>;
  timeout: number;
}

// 支持的AI模型类型
export type AIModelType = 'deepseek-r1' | 'doubao' | 'tongyiqianwen' | 'chatgpt' | string;

// 默认配置常量
const DEFAULT_CONFIG: AIModelSettings = {
  defaultModel: 'deepseek-r1',
  models: {
    'deepseek-r1': {
      apiKey: '',
      apiBase: 'https://api.deepseek.com'
    },
    'doubao': {
      apiKey: '',
      apiBase: 'https://api.doubao.com'
    },
    'tongyiqianwen': {
      apiKey: '',
      apiBase: 'https://api.tongyi.aliyun.com'
    },
    'chatgpt': {
      apiKey: '',
      apiBase: 'https://api.openai.com'
    }
  },
  timeout: 60
};

// 本地存储键名
const STORAGE_KEY = 'aiModelSettings';

/**
 * AI模型配置管理器类
 * 单例模式实现，统一管理应用中的AI模型配置
 */
export class AIModelConfigManager {
  private static instance: AIModelConfigManager;
  private settings: AIModelSettings;

  /**
   * 私有构造函数，防止外部实例化
   * 初始化时加载本地存储的配置
   */
  private constructor() {
    this.settings = this.loadConfig();
  }

  /**
   * 获取单例实例
   * @returns AIModelConfigManager实例
   */
  public static getInstance(): AIModelConfigManager {
    if (!AIModelConfigManager.instance) {
      AIModelConfigManager.instance = new AIModelConfigManager();
    }
    return AIModelConfigManager.instance;
  }

  /**
   * 从localStorage加载配置
   * @returns 加载的配置或默认配置
   */
  private loadConfig(): AIModelSettings {
    try {
      const savedConfig = localStorage.getItem(STORAGE_KEY);
      if (savedConfig) {
        // 合并保存的配置和默认配置，确保结构完整
        const parsedConfig = JSON.parse(savedConfig);
        return this.mergeConfigs(DEFAULT_CONFIG, parsedConfig);
      }
    } catch (error) {
      console.error('加载AI模型配置失败:', error);
    }
    return { ...DEFAULT_CONFIG };
  }

  /**
   * 合并配置对象
   * @param defaultConfig 默认配置
   * @param customConfig 自定义配置
   * @returns 合并后的配置
   */
  private mergeConfigs(defaultConfig: AIModelSettings, customConfig: any): AIModelSettings {
    const merged: AIModelSettings = { ...defaultConfig };

    if (customConfig.defaultModel) {
      merged.defaultModel = customConfig.defaultModel;
    }

    if (customConfig.timeout && typeof customConfig.timeout === 'number') {
      merged.timeout = Math.max(10, Math.min(300, customConfig.timeout));
    }

    if (customConfig.models && typeof customConfig.models === 'object') {
      Object.keys(defaultConfig.models).forEach(modelType => {
        if (customConfig.models[modelType]) {
          merged.models[modelType] = {
            ...defaultConfig.models[modelType],
            ...customConfig.models[modelType]
          };
        }
      });
    }

    return merged;
  }

  /**
   * 保存配置到localStorage
   * @returns 是否保存成功
   */
  public saveConfig(): boolean {
    try {
      localStorage.setItem(STORAGE_KEY, JSON.stringify(this.settings));
      return true;
    } catch (error) {
      console.error('保存AI模型配置失败:', error);
      return false;
    }
  }

  /**
   * 获取当前所有配置
   * @returns 完整配置对象
   */
  public getAllSettings(): AIModelSettings {
    return { ...this.settings };
  }

  /**
   * 获取默认模型类型
   * @returns 默认模型类型字符串
   */
  public getDefaultModel(): string {
    return this.settings.defaultModel;
  }

  /**
   * 设置默认模型类型
   * @param modelType 模型类型
   * @returns 是否设置成功
   */
  public setDefaultModel(modelType: string): boolean {
    if (typeof modelType === 'string' && modelType.trim()) {
      this.settings.defaultModel = modelType;
      return this.saveConfig();
    }
    return false;
  }

  /**
   * 获取API调用超时时间（秒）
   * @returns 超时时间
   */
  public getTimeout(): number {
    return this.settings.timeout;
  }

  /**
   * 设置API调用超时时间
   * @param seconds 秒数（10-300之间）
   * @returns 是否设置成功
   */
  public setTimeout(seconds: number): boolean {
    const validSeconds = Math.max(10, Math.min(300, seconds));
    if (typeof seconds === 'number' && !isNaN(seconds)) {
      this.settings.timeout = validSeconds;
      return this.saveConfig();
    }
    return false;
  }

  /**
   * 获取指定模型的配置
   * @param modelType 模型类型
   * @returns 模型配置对象
   */
  public getModelConfig(modelType: AIModelType): ModelConfig {
    if (!this.settings.models[modelType]) {
      // 如果模型类型不存在，创建一个默认配置
      this.settings.models[modelType] = {
        apiKey: '',
        apiBase: ''
      };
    }
    return { ...this.settings.models[modelType] };
  }

  /**
   * 设置指定模型的配置
   * @param modelType 模型类型
   * @param config 模型配置
   * @returns 是否设置成功
   */
  public setModelConfig(modelType: AIModelType, config: Partial<ModelConfig>): boolean {
    if (typeof modelType !== 'string' || !modelType.trim()) {
      return false;
    }

    if (!this.settings.models[modelType]) {
      this.settings.models[modelType] = {
        apiKey: '',
        apiBase: ''
      };
    }

    // 更新配置
    this.settings.models[modelType] = {
      ...this.settings.models[modelType],
      ...config
    };

    return this.saveConfig();
  }

  /**
   * 设置模型API密钥
   * @param modelType 模型类型
   * @param apiKey API密钥
   * @returns 是否设置成功
   */
  public setApiKey(modelType: AIModelType, apiKey: string): boolean {
    return this.setModelConfig(modelType, { apiKey: apiKey || '' });
  }

  /**
   * 设置模型API基础URL
   * @param modelType 模型类型
   * @param apiBase API基础URL
   * @returns 是否设置成功
   */
  public setApiBase(modelType: AIModelType, apiBase: string): boolean {
    return this.setModelConfig(modelType, { apiBase: apiBase || '' });
  }

  /**
   * 验证API密钥格式
   * @param apiKey API密钥
   * @param modelType 模型类型
   * @returns 是否有效
   */
  public validateApiKey(apiKey: string, modelType: AIModelType = 'deepseek-r1'): boolean {
    if (!apiKey || typeof apiKey !== 'string') {
      return false;
    }

    // 去除前后空格
    const trimmedKey = apiKey.trim();
    
    // 根据不同模型类型进行简单的格式验证
    switch (modelType) {
      case 'deepseek-r1':
        // DeepSeek API密钥通常以sk-开头，长度约为40-60个字符
        return trimmedKey.startsWith('sk-') && trimmedKey.length >= 40 && trimmedKey.length <= 60;
      case 'chatgpt':
        // OpenAI API密钥通常以sk-开头，长度约为50个字符
        return trimmedKey.startsWith('sk-') && trimmedKey.length >= 50;
      case 'doubao':
        // 豆包API密钥格式可能有所不同，这里做简单验证
        return trimmedKey.length > 0;
      case 'tongyiqianwen':
        // 通义千问API密钥格式可能有所不同，这里做简单验证
        return trimmedKey.length > 0;
      default:
        // 其他模型类型，只要不为空就认为有效
        return trimmedKey.length > 0;
    }
  }

  /**
   * 重置配置为默认值
   * @returns 是否重置成功
   */
  public resetToDefault(): boolean {
    this.settings = { ...DEFAULT_CONFIG };
    return this.saveConfig();
  }

  /**
   * 检查配置是否有效（至少有一个模型配置了API密钥）
   * @returns 配置是否有效
   */
  public isConfigValid(): boolean {
    return Object.values(this.settings.models).some(
      model => model.apiKey && this.validateApiKey(model.apiKey)
    );
  }

  /**
   * 获取DeepSeek-R1模型的配置
   * @returns DeepSeek-R1配置
   */
  public getDeepSeekConfig(): ModelConfig {
    return this.getModelConfig('deepseek-r1');
  }

  /**
   * 设置DeepSeek-R1模型的配置
   * @param apiKey API密钥
   * @param apiBase API基础URL
   * @returns 是否设置成功
   */
  public setDeepSeekConfig(apiKey: string, apiBase: string = DEFAULT_CONFIG.models['deepseek-r1'].apiBase): boolean {
    return this.setModelConfig('deepseek-r1', { apiKey, apiBase });
  }
}